import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px
import plotly.graph_objects as go

from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold, RandomizedSearchCV
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier
from sklearn.svm import SVC
from sklearn.metrics import (
    accuracy_score,
    precision_score,
    recall_score,
    f1_score,
    classification_report,
    confusion_matrix,
    precision_recall_curve,
    auc
)

import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)

# Read dataset
df = pd.read_csv('digital_marketing_campaign_dataset.csv')
df

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 8000 entries, 0 to 7999
Data columns (total 20 columns):
 #   Column               Non-Null Count  Dtype  
---  ------               --------------  -----  
 0   CustomerID           8000 non-null   int64  
 1   Age                  8000 non-null   int64  
 2   Gender               8000 non-null   object 
 3   Income               8000 non-null   int64  
 4   CampaignChannel      8000 non-null   object 
 5   CampaignType         8000 non-null   object 
 6   AdSpend              8000 non-null   float64
 7   ClickThroughRate     8000 non-null   float64
 8   ConversionRate       8000 non-null   float64
 9   WebsiteVisits        8000 non-null   int64  
 10  PagesPerVisit        8000 non-null   float64
 11  TimeOnSite           8000 non-null   float64
 12  SocialShares         8000 non-null   int64  
 13  EmailOpens           8000 non-null   int64  
 14  EmailClicks          8000 non-null   int64  
 15  PreviousPurchases    8000 non-null   int64  
 16  LoyaltyPoints        8000 non-null   int64  
 17  AdvertisingPlatform  8000 non-null   object 
 18  AdvertisingTool      8000 non-null   object 
 19  Conversion           8000 non-null   int64  
dtypes: float64(5), int64(10), object(5)
memory usage: 1.2+ MB

AgeGroup
36-45    1603
46-55    1536
56-65    1529
26-35    1522
18-25    1045
65+       617
<18       148
Name: count, dtype: int64

Total new customers: 838
Total conversions from new customers: 648
First-time conversion rate: 77.33%

Number of duplicate rows: 0

0

['Age',
 'Income',
 'AdSpend',
 'ClickThroughRate',
 'ConversionRate',
 'WebsiteVisits',
 'PagesPerVisit',
 'TimeOnSite',
 'SocialShares',
 'EmailOpens',
 'EmailClicks',
 'PreviousPurchases',
 'LoyaltyPoints']

Age                  0
Income               0
AdSpend              0
ClickThroughRate     0
ConversionRate       0
WebsiteVisits        0
PagesPerVisit        0
TimeOnSite           0
SocialShares         0
EmailOpens           0
EmailClicks          0
PreviousPurchases    0
LoyaltyPoints        0
dtype: int64

<Figure size 1500x800 with 0 Axes>

['Gender', 'CampaignChannel', 'CampaignType']

Index(['Age', 'Income', 'AdSpend', 'ClickThroughRate', 'ConversionRate',
       'WebsiteVisits', 'PagesPerVisit', 'TimeOnSite', 'SocialShares',
       'EmailOpens', 'EmailClicks', 'PreviousPurchases', 'LoyaltyPoints',
       'Conversion', 'Gender_Female', 'Gender_Male', 'CampaignChannel_Email',
       'CampaignChannel_PPC', 'CampaignChannel_Referral',
       'CampaignChannel_SEO', 'CampaignChannel_Social Media',
       'CampaignType_Awareness', 'CampaignType_Consideration',
       'CampaignType_Conversion', 'CampaignType_Retention'],
      dtype='object')

# Read dataset
df = pd.read_csv('digital_marketing_campaign_dataset.csv')
df

df.describe().T

# Display a concise summary of the dataframe
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 8000 entries, 0 to 7999
Data columns (total 20 columns):
 #   Column               Non-Null Count  Dtype  
---  ------               --------------  -----  
 0   CustomerID           8000 non-null   int64  
 1   Age                  8000 non-null   int64  
 2   Gender               8000 non-null   object 
 3   Income               8000 non-null   int64  
 4   CampaignChannel      8000 non-null   object 
 5   CampaignType         8000 non-null   object 
 6   AdSpend              8000 non-null   float64
 7   ClickThroughRate     8000 non-null   float64
 8   ConversionRate       8000 non-null   float64
 9   WebsiteVisits        8000 non-null   int64  
 10  PagesPerVisit        8000 non-null   float64
 11  TimeOnSite           8000 non-null   float64
 12  SocialShares         8000 non-null   int64  
 13  EmailOpens           8000 non-null   int64  
 14  EmailClicks          8000 non-null   int64  
 15  PreviousPurchases    8000 non-null   int64  
 16  LoyaltyPoints        8000 non-null   int64  
 17  AdvertisingPlatform  8000 non-null   object 
 18  AdvertisingTool      8000 non-null   object 
 19  Conversion           8000 non-null   int64  
dtypes: float64(5), int64(10), object(5)
memory usage: 1.2+ MB

AgeGroup
36-45    1603
46-55    1536
56-65    1529
26-35    1522
18-25    1045
65+       617
<18       148
Name: count, dtype: int64

Total new customers: 838
Total conversions from new customers: 648
First-time conversion rate: 77.33%

Number of duplicate rows: 0

0

['Age',
 'Income',
 'AdSpend',
 'ClickThroughRate',
 'ConversionRate',
 'WebsiteVisits',
 'PagesPerVisit',
 'TimeOnSite',
 'SocialShares',
 'EmailOpens',
 'EmailClicks',
 'PreviousPurchases',
 'LoyaltyPoints']

Age                  0
Income               0
AdSpend              0
ClickThroughRate     0
ConversionRate       0
WebsiteVisits        0
PagesPerVisit        0
TimeOnSite           0
SocialShares         0
EmailOpens           0
EmailClicks          0
PreviousPurchases    0
LoyaltyPoints        0
dtype: int64

<Figure size 1500x800 with 0 Axes>

['Gender', 'CampaignChannel', 'CampaignType']

Index(['Age', 'Income', 'AdSpend', 'ClickThroughRate', 'ConversionRate',
       'WebsiteVisits', 'PagesPerVisit', 'TimeOnSite', 'SocialShares',
       'EmailOpens', 'EmailClicks', 'PreviousPurchases', 'LoyaltyPoints',
       'Conversion', 'Gender_Female', 'Gender_Male', 'CampaignChannel_Email',
       'CampaignChannel_PPC', 'CampaignChannel_Referral',
       'CampaignChannel_SEO', 'CampaignChannel_Social Media',
       'CampaignType_Awareness', 'CampaignType_Consideration',
       'CampaignType_Conversion', 'CampaignType_Retention'],
      dtype='object')

# Display a concise summary of the dataframe
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 8000 entries, 0 to 7999
Data columns (total 20 columns):
 #   Column               Non-Null Count  Dtype  
---  ------               --------------  -----  
 0   CustomerID           8000 non-null   int64  
 1   Age                  8000 non-null   int64  
 2   Gender               8000 non-null   object 
 3   Income               8000 non-null   int64  
 4   CampaignChannel      8000 non-null   object 
 5   CampaignType         8000 non-null   object 
 6   AdSpend              8000 non-null   float64
 7   ClickThroughRate     8000 non-null   float64
 8   ConversionRate       8000 non-null   float64
 9   WebsiteVisits        8000 non-null   int64  
 10  PagesPerVisit        8000 non-null   float64
 11  TimeOnSite           8000 non-null   float64
 12  SocialShares         8000 non-null   int64  
 13  EmailOpens           8000 non-null   int64  
 14  EmailClicks          8000 non-null   int64  
 15  PreviousPurchases    8000 non-null   int64  
 16  LoyaltyPoints        8000 non-null   int64  
 17  AdvertisingPlatform  8000 non-null   object 
 18  AdvertisingTool      8000 non-null   object 
 19  Conversion           8000 non-null   int64  
dtypes: float64(5), int64(10), object(5)
memory usage: 1.2+ MB

# Get the summary statistics for numerical variables
df.describe().T

AgeGroup
36-45    1603
46-55    1536
56-65    1529
26-35    1522
18-25    1045
65+       617
<18       148
Name: count, dtype: int64

Total new customers: 838
Total conversions from new customers: 648
First-time conversion rate: 77.33%

Number of duplicate rows: 0

0

['Age',
 'Income',
 'AdSpend',
 'ClickThroughRate',
 'ConversionRate',
 'WebsiteVisits',
 'PagesPerVisit',
 'TimeOnSite',
 'SocialShares',
 'EmailOpens',
 'EmailClicks',
 'PreviousPurchases',
 'LoyaltyPoints']

Age                  0
Income               0
AdSpend              0
ClickThroughRate     0
ConversionRate       0
WebsiteVisits        0
PagesPerVisit        0
TimeOnSite           0
SocialShares         0
EmailOpens           0
EmailClicks          0
PreviousPurchases    0
LoyaltyPoints        0
dtype: int64

<Figure size 1500x800 with 0 Axes>

['Gender', 'CampaignChannel', 'CampaignType']

Index(['Age', 'Income', 'AdSpend', 'ClickThroughRate', 'ConversionRate',
       'WebsiteVisits', 'PagesPerVisit', 'TimeOnSite', 'SocialShares',
       'EmailOpens', 'EmailClicks', 'PreviousPurchases', 'LoyaltyPoints',
       'Conversion', 'Gender_Female', 'Gender_Male', 'CampaignChannel_Email',
       'CampaignChannel_PPC', 'CampaignChannel_Referral',
       'CampaignChannel_SEO', 'CampaignChannel_Social Media',
       'CampaignType_Awareness', 'CampaignType_Consideration',
       'CampaignType_Conversion', 'CampaignType_Retention'],
      dtype='object')

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 8000 entries, 0 to 7999
Data columns (total 25 columns):
 #   Column                        Non-Null Count  Dtype  
---  ------                        --------------  -----  
 0   Age                           8000 non-null   int64  
 1   Income                        8000 non-null   int64  
 2   AdSpend                       8000 non-null   float64
 3   ClickThroughRate              8000 non-null   float64
 4   ConversionRate                8000 non-null   float64
 5   WebsiteVisits                 8000 non-null   int64  
 6   PagesPerVisit                 8000 non-null   float64
 7   TimeOnSite                    8000 non-null   float64
 8   SocialShares                  8000 non-null   int64  
 9   EmailOpens                    8000 non-null   int64  
 10  EmailClicks                   8000 non-null   int64  
 11  PreviousPurchases             8000 non-null   int64  
 12  LoyaltyPoints                 8000 non-null   int64  
 13  Conversion                    8000 non-null   int64  
 14  Gender_Female                 8000 non-null   int32  
 15  Gender_Male                   8000 non-null   int32  
 16  CampaignChannel_Email         8000 non-null   int32  
 17  CampaignChannel_PPC           8000 non-null   int32  
 18  CampaignChannel_Referral      8000 non-null   int32  
 19  CampaignChannel_SEO           8000 non-null   int32  
 20  CampaignChannel_Social Media  8000 non-null   int32  
 21  CampaignType_Awareness        8000 non-null   int32  
 22  CampaignType_Consideration    8000 non-null   int32  
 23  CampaignType_Conversion       8000 non-null   int32  
 24  CampaignType_Retention        8000 non-null   int32  
dtypes: float64(5), int32(11), int64(9)
memory usage: 1.2 MB

# Get the summary statistics for numerical variables
df.describe().T

# Get the summary statistics for categorical variables
df.describe(include='object')

AgeGroup
36-45    1603
46-55    1536
56-65    1529
26-35    1522
18-25    1045
65+       617
<18       148
Name: count, dtype: int64

Total new customers: 838
Total conversions from new customers: 648
First-time conversion rate: 77.33%

Number of duplicate rows: 0

0

['Age',
 'Income',
 'AdSpend',
 'ClickThroughRate',
 'ConversionRate',
 'WebsiteVisits',
 'PagesPerVisit',
 'TimeOnSite',
 'SocialShares',
 'EmailOpens',
 'EmailClicks',
 'PreviousPurchases',
 'LoyaltyPoints']

Age                  0
Income               0
AdSpend              0
ClickThroughRate     0
ConversionRate       0
WebsiteVisits        0
PagesPerVisit        0
TimeOnSite           0
SocialShares         0
EmailOpens           0
EmailClicks          0
PreviousPurchases    0
LoyaltyPoints        0
dtype: int64

<Figure size 1500x800 with 0 Axes>

['Gender', 'CampaignChannel', 'CampaignType']

Index(['Age', 'Income', 'AdSpend', 'ClickThroughRate', 'ConversionRate',
       'WebsiteVisits', 'PagesPerVisit', 'TimeOnSite', 'SocialShares',
       'EmailOpens', 'EmailClicks', 'PreviousPurchases', 'LoyaltyPoints',
       'Conversion', 'Gender_Female', 'Gender_Male', 'CampaignChannel_Email',
       'CampaignChannel_PPC', 'CampaignChannel_Referral',
       'CampaignChannel_SEO', 'CampaignChannel_Social Media',
       'CampaignType_Awareness', 'CampaignType_Consideration',
       'CampaignType_Conversion', 'CampaignType_Retention'],
      dtype='object')

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 8000 entries, 0 to 7999
Data columns (total 25 columns):
 #   Column                        Non-Null Count  Dtype  
---  ------                        --------------  -----  
 0   Age                           8000 non-null   int64  
 1   Income                        8000 non-null   int64  
 2   AdSpend                       8000 non-null   float64
 3   ClickThroughRate              8000 non-null   float64
 4   ConversionRate                8000 non-null   float64
 5   WebsiteVisits                 8000 non-null   int64  
 6   PagesPerVisit                 8000 non-null   float64
 7   TimeOnSite                    8000 non-null   float64
 8   SocialShares                  8000 non-null   int64  
 9   EmailOpens                    8000 non-null   int64  
 10  EmailClicks                   8000 non-null   int64  
 11  PreviousPurchases             8000 non-null   int64  
 12  LoyaltyPoints                 8000 non-null   int64  
 13  Conversion                    8000 non-null   int64  
 14  Gender_Female                 8000 non-null   int32  
 15  Gender_Male                   8000 non-null   int32  
 16  CampaignChannel_Email         8000 non-null   int32  
 17  CampaignChannel_PPC           8000 non-null   int32  
 18  CampaignChannel_Referral      8000 non-null   int32  
 19  CampaignChannel_SEO           8000 non-null   int32  
 20  CampaignChannel_Social Media  8000 non-null   int32  
 21  CampaignType_Awareness        8000 non-null   int32  
 22  CampaignType_Consideration    8000 non-null   int32  
 23  CampaignType_Conversion       8000 non-null   int32  
 24  CampaignType_Retention        8000 non-null   int32  
dtypes: float64(5), int32(11), int64(9)
memory usage: 1.2 MB

# Get the summary statistics for categorical variables
df.describe(include='object')

# Drop the unnecessary columns
df = df.drop(['CustomerID', 'AdvertisingPlatform', 'AdvertisingTool'], axis=1)

# Display the updated dataframe
df.head()

# Step 1: Define continuous features manually (excluding ID, target, and object types)
continuous_features = [
    'Age', 'Income', 'AdSpend', 'ClickThroughRate', 'ConversionRate',
    'WebsiteVisits', 'PagesPerVisit', 'TimeOnSite', 'SocialShares',
    'EmailOpens', 'EmailClicks', 'PreviousPurchases', 'LoyaltyPoints'
]

# Step 2: Create a new DataFrame containing only the continuous features
df_continuous = df[continuous_features]
df_continuous.head()

# Filter out continuous features for the univariate analysis
df_continuous = df[continuous_features]

# Calculate number of plots needed
n_features = len(df_continuous.columns)
n_cols = 3
n_rows = (n_features + n_cols - 1) // n_cols  # Auto-adjust rows based on number of features

# Set up the subplot
fig, ax = plt.subplots(nrows=n_rows, ncols=n_cols, figsize=(15, 5 * n_rows))
ax = ax.flatten()  # Flatten to simple 1D array for easy indexing

# Loop to plot histograms for each continuous feature
for i, col in enumerate(df_continuous.columns):
    values, bin_edges = np.histogram(df_continuous[col], 
                                     range=(np.floor(df_continuous[col].min()), np.ceil(df_continuous[col].max())))
    
    graph = sns.histplot(data=df_continuous, x=col, bins=bin_edges, kde=True, ax=ax[i],
                         edgecolor='none', color='#4a90e2', alpha=0.7, line_kws={'lw': 2, 'color': '#003366'})
    
    ax[i].set_xlabel(col, fontsize=15)
    ax[i].set_ylabel('Count', fontsize=12)
    ax[i].set_xticks(np.round(bin_edges, 1))
    ax[i].set_xticklabels(ax[i].get_xticks(), rotation=45)
    ax[i].grid(color='lightgrey')
    
    # Annotate counts
    for j, p in enumerate(graph.patches):
        height = p.get_height()
        if height > 0:
            ax[i].annotate(f'{int(height)}', 
                           (p.get_x() + p.get_width() / 2., height), 
                           ha='center', va='bottom', 
                           fontsize=8, fontweight="bold")

    # Mean and Std box
    textstr = '\n'.join((
        r'$\mu=%.2f$' % df_continuous[col].mean(),
        r'$\sigma=%.2f$' % df_continuous[col].std()
    ))
    ax[i].text(0.75, 0.9, textstr, transform=ax[i].transAxes, fontsize=10, verticalalignment='top',
               color='white', bbox=dict(boxstyle='round', facecolor='#4a90e2', edgecolor='white', pad=0.5))

# Turn off any unused subplots
for j in range(i+1, len(ax)):
    ax[j].axis('off')

plt.suptitle('Distribution of Continuous Variables', fontsize=22)
plt.tight_layout()
plt.subplots_adjust(top=0.92)
plt.show()

# Filter out categorical features for the univariate analysis
categorical_features = ['Gender', 'CampaignChannel', 'CampaignType']
df_categorical = df[categorical_features]
df_categorical.head(8)

# Set up the subplot for a 2x2 layout
fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(14, 10))

# Flatten the axes array for easier indexing
ax = ax.flatten()

# Loop to plot bar charts for each categorical feature
for i, col in enumerate(categorical_features):
    # Calculate frequency percentages
    value_counts = df[col].value_counts(normalize=True).mul(100).sort_values()
    
    # Plot bar chart with the specified color
    value_counts.plot(kind='barh', ax=ax[i], width=0.8, color='#4a90e2')
    
    # Add frequency percentages to the bars
    for index, value in enumerate(value_counts):
        ax[i].text(value, index, f'{round(value, 1)}%', fontsize=12, weight='bold', va='center')
    
    ax[i].set_xlim([0, 100])
    ax[i].set_xlabel('Frequency Percentage', fontsize=12)
    ax[i].set_title(f'{col}', fontsize=18)
    ax[i].grid(axis='x', color='lightgrey')

# Turn off the last (empty) subplot
ax[3].axis('off')

# Adjust layout
plt.suptitle('Distribution of Categorical Variables', fontsize=24)
plt.tight_layout()
plt.subplots_adjust(top=0.9)
plt.show()

# Define colors for each Conversion category
conversion_colors = {0: '#99ccff', 1: '#007acc'}

# Create the subplots
n_features = len(df_continuous.columns)
fig, ax = plt.subplots(n_features, 2, figsize=(18, 5 * n_features), gridspec_kw={'width_ratios': [1, 2]})

# Ensure ax is 2D
if n_features == 1:
    ax = [ax]  # Make it a list of one pair of axes

# Set background color
fig.patch.set_facecolor('#d0f0fd')

# Loop through each continuous feature
for i, col in enumerate(df_continuous.columns):
    # Precompute mean values grouped by Conversion
    grouped = df.groupby("Conversion")[col].mean().reset_index()

    # Barplot using precomputed values
    graph = sns.barplot(
        x="Conversion", y=col, data=grouped, ax=ax[i][0],
        palette=[conversion_colors[val] for val in grouped["Conversion"]],
        width=0.5
    )
    
    # KDE plots
    sns.kdeplot(
        data=df[df["Conversion"] == 0], x=col, fill=True, linewidth=2, 
        ax=ax[i][1], label='0', color='#99ccff'
    )
    sns.kdeplot(
        data=df[df["Conversion"] == 1], x=col, fill=True, linewidth=2, 
        ax=ax[i][1], label='1', color='#007acc'
    )

    ax[i][1].set_yticks([])
    ax[i][1].legend(
        title='Conversion', 
        loc='upper right', 
        fontsize='13', 
        title_fontsize='14'
    )

    # Add value labels
    for cont in graph.containers:
        graph.bar_label(cont, fmt='%.2f', label_type='edge', padding=3)

# Set title and layout
plt.suptitle('Numerical Features vs Conversion Distribution', fontsize=24, fontweight='bold')
plt.tight_layout(rect=[0, 0, 1, 0.98])
plt.show()

df_categorical.head()

from matplotlib.colors import ListedColormap

fig, ax = plt.subplots(nrows=1, ncols=3, figsize=(18, 6))  # 1 row, 3 columns

for i, col in enumerate(df_categorical[:3]):  # Ensure only 3 features are used
    
    # Cross-tab for counts
    cross_tab = pd.crosstab(index=df[col], columns=df['Conversion'])
    
    # Cross-tab for proportions
    cross_tab_prop = pd.crosstab(index=df[col], columns=df['Conversion'], normalize='index')

    # Define theme colormap
    cmp = ListedColormap(['#99ccff', '#007acc'])
    
    # Plot stacked bar
    cross_tab_prop.plot(kind='bar', ax=ax[i], stacked=True, width=0.8, colormap=cmp,
                        legend=False, ylabel='Proportion', sharey=True)
    
    # Add count and percent labels
    for idx, val in enumerate(cross_tab.index.values):
        for (proportion, count, y_location) in zip(cross_tab_prop.loc[val], cross_tab.loc[val], cross_tab_prop.loc[val].cumsum()):
            ax[i].text(x=idx - 0.3, y=(y_location - proportion) + (proportion / 2) - 0.03,
                       s=f'    {count}\n({np.round(proportion * 100, 1)}%)', 
                       color="black", fontsize=12, fontweight="bold")  # Increased label font size
    
    # Add enlarged legend
    ax[i].legend(title='Conversion', title_fontsize=12, fontsize=11, loc='upper right')  # Increased font sizes

    ax[i].set_ylim([0, 1.12])
    ax[i].set_xticklabels(ax[i].get_xticklabels(), rotation=0)

plt.suptitle('Categorical Features vs Conversion — 100% Stacked Barplots', fontsize=20)
plt.tight_layout()
plt.show()

plt.figure(figsize=(16, 10))
corr = df.select_dtypes(include=[np.number]).corr()
sns.heatmap(corr, annot=True, cmap='coolwarm', linewidths=0.5)
plt.title('Correlation Heatmap of Campaign Variables')
plt.tight_layout()
plt.show()

plt.figure(figsize=(4, 4))
sns.boxplot(x='Gender', y='Income', data=df, palette={'Male': '#4a90e2', 'Female': '#007acc'})
plt.title('Income Distribution by Gender')
plt.xlabel('Gender')
plt.ylabel('Income')
plt.tight_layout()
plt.show()

conversion_by_type = df.groupby('CampaignType')['Conversion'].mean()
conversion_by_type.plot.pie(
    autopct='%1.1f%%',
    startangle=90,
    figsize=(5, 5),
    ylabel='',
    colors=sns.color_palette("tab10")
)
plt.title('Conversion Rate by Campaign Type')
plt.tight_layout()
plt.show()

# List of engagement metrics
engagement_metrics = ['WebsiteVisits', 'PagesPerVisit', 'TimeOnSite']

# Define color mapping
conversion_colors = {0: '#99ccff', 1: '#007acc'}

# Set up subplots
fig, axes = plt.subplots(1, 3, figsize=(12, 6))

# Loop through each metric and plot a barplot
for i, metric in enumerate(engagement_metrics):
    # Calculate the mean of each metric by Conversion
    mean_data = df.groupby('Conversion')[metric].mean().reset_index()

    # Create a palette list based on the Conversion values in mean_data
    palette = [conversion_colors[val] for val in mean_data['Conversion']]

    # Create a bar plot with custom colors
    ax = sns.barplot(x='Conversion', y=metric, data=mean_data, ax=axes[i], palette=palette)
    
    # Add percentage inside the bars
    for p in ax.patches:
        height = p.get_height()
        percentage = (height / mean_data[metric].sum()) * 100
        # Annotate percentage inside the bar
        ax.annotate(f'{height:.2f}\n({percentage:.1f}%)', 
                    (p.get_x() + p.get_width() / 2., height / 2),  # Position inside the bar
                    ha='center', va='center', fontsize=11, color='black', weight='bold')  # White text for visibility

    # Set titles and labels
    axes[i].set_title(f'{metric} by Conversion')
    axes[i].set_xlabel('Conversion')
    axes[i].set_ylabel(metric)

# Adjust layout
plt.tight_layout()
plt.show()

# Group and unstack to get counts
conversion_gender = df.groupby(['Gender', 'Conversion']).size().unstack()

# Plot the bar chart
ax = conversion_gender.plot(kind='bar', figsize=(6, 5), color=['#FF6347', '#4682B4'])

# Title and labels
plt.title('Conversion Distribution by Gender')
plt.xlabel('Gender')
plt.ylabel('Count')
plt.xticks(rotation=0)

# Annotate bars with count and percentage inside the bars
for i, container in enumerate(ax.containers):
    for j, bar in enumerate(container):
        height = bar.get_height()
        if height > 0:
            # Total count for this gender
            gender = conversion_gender.index[j]
            total = conversion_gender.loc[gender].sum()
            percent = (height / total) * 100
            # Annotate count and percentage inside the bar
            ax.annotate(f'{int(height)}\n({percent:.1f}%)',
                        (bar.get_x() + bar.get_width() / 2, height / 2),  # Position inside the bar (halfway)
                        ha='center', va='center', fontsize=10, fontweight='bold', color='black')

# Show the plot
plt.tight_layout()
plt.show()

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Calculate the total conversions per campaign channel
campaign_channels = df.groupby('CampaignChannel')['Conversion'].sum().reset_index()

# Rename columns
campaign_channels.columns = ['CampaignChannel', 'TotalConversions']

# Calculate total count for percentages
total_conversions = campaign_channels['TotalConversions'].sum()

# Create barplot
plt.figure(figsize=(7, 4))
ax = sns.barplot(data=campaign_channels, x='CampaignChannel', y='TotalConversions', palette='tab10')

# Add sum and percentage inside the bars
for p in ax.patches:
    total = int(p.get_height())
    percent = (total / total_conversions) * 100
    ax.annotate(f'{total}\n({percent:.1f}%)',
                (p.get_x() + p.get_width() / 2., p.get_height() * 0.5),  # Halfway up the bar
                ha='center', va='center', fontsize=11, color='black', weight='bold')

# Titles and labels
plt.title("Total Conversions by Campaign Channel")
plt.xlabel("Campaign Channel")
plt.ylabel("Total Conversions")
plt.tight_layout()
plt.show()

import matplotlib.patches as mpatches

# Prepare the data: group and count conversions
conversion_counts = df.groupby(['CampaignChannel', 'Conversion']).size().reset_index(name='Count')

# Create barplot
plt.figure(figsize=(10, 5))
ax = sns.barplot(data=conversion_counts, x='CampaignChannel', y='Count', hue='Conversion', palette=['#d95f02', '#1b9e77'])

# Annotate each bar with its count
for p in ax.patches:
    height = p.get_height()
    if height > 0:
        ax.annotate(f'{int(height)}',
                    (p.get_x() + p.get_width() / 2., height),
                    ha='center', va='bottom',
                    fontsize=10, color='black',
                    xytext=(0, 4), textcoords='offset points')

# Custom legend with matching colors
legend_handles = [
    mpatches.Patch(color='#d95f02', label='No (0)'),
    mpatches.Patch(color='#1b9e77', label='Yes (1)')
]
plt.legend(title='Conversion', handles=legend_handles)

# Add titles and labels
plt.title('Conversions per Campaign Channel')
plt.xlabel('Campaign Channel')
plt.ylabel('Number of Conversions')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Get gender distribution by campaign channel
campaign_gender_counts = df.groupby(['CampaignChannel', 'Gender']).size().reset_index(name='Count')

# Create barplot
plt.figure(figsize=(10, 6))
ax = sns.barplot(data=campaign_gender_counts, x='CampaignChannel', y='Count', hue='Gender', palette='tab10')

# Add numbers on top of the bars
for p in ax.patches:
    ax.annotate(f'{p.get_height()}', (p.get_x() + p.get_width() / 2., p.get_height()), ha='center', va='center', fontsize=12, color='black', weight='bold', xytext=(0, 5), textcoords='offset points')

# Titles and labels
plt.title("Gender Distribution by Campaign Channel")
plt.xlabel("Campaign Channel")
plt.ylabel("Number of Conversions")
plt.tight_layout()
plt.show()

# Group data by Gender and CampaignChannel
channel_gender = df.groupby(['Gender', 'CampaignChannel']).size().unstack()

# Plot the grouped bar chart with custom colors
ax = channel_gender.plot(kind='bar', figsize=(8, 6), color=plt.cm.Set2.colors, edgecolor='black')

# Add value labels on each bar
for container in ax.containers:
    ax.bar_label(container, fmt='%d', label_type='edge', fontsize=9, padding=2)

# Chart formatting
plt.title('Campaign Channel Distribution by Gender')
plt.xlabel('Gender')
plt.ylabel('Count')
plt.xticks(rotation=0)
plt.legend(title='Campaign Channel')
plt.tight_layout()
plt.show()

df_copy = df.copy()  # making a copy of dataset

# Define bins and labels
bins = [0, 18, 25, 35, 45, 55, 65, np.inf]
labels = ['<18', '18-25', '26-35', '36-45', '46-55', '56-65', '65+']

# Create AgeGroup column
df_copy['AgeGroup'] = pd.cut(df_copy['Age'], bins=bins, labels=labels)

# Convert to string type
df_copy['AgeGroup'] = df_copy['AgeGroup'].astype(str)

# Check distribution
df_copy['AgeGroup'].value_counts()

AgeGroup
36-45    1603
46-55    1536
56-65    1529
26-35    1522
18-25    1045
65+       617
<18       148
Name: count, dtype: int64

# Define custom order for age groups
age_order = ['<18', '18-25', '26-35', '36-45', '46-55', '56-65', '65+']

# Ensure 'AgeGroup' is a categorical with correct order
df_copy['AgeGroup'] = pd.Categorical(df_copy['AgeGroup'], categories=age_order, ordered=True)

# Bar plot in specified order
df_copy['AgeGroup'].value_counts().reindex(age_order).plot(
    kind='bar',
    color='#69b3a2',
    edgecolor='black'
)

plt.title('Age Group Distribution')
plt.xlabel('Age Group')
plt.ylabel('Count')
plt.xticks(rotation=45)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

# Group by AgeGroup and Conversion
conversion_age = df_copy.groupby(['AgeGroup', 'Conversion']).size().unstack()

# Plot with custom colors
ax = conversion_age.plot(kind='bar', figsize=(8, 6), color=['#d95f02', '#1b9e77'], edgecolor='black')

# Add value labels on each bar
for p in ax.patches:
    height = p.get_height()
    if height > 0:
        ax.annotate(f'{int(height)}', 
                    (p.get_x() + p.get_width() / 2., height), 
                    ha='center', va='bottom',
                    fontsize=9, color='black',
                    xytext=(0, 3), textcoords='offset points')

# Labels and formatting
plt.title('Conversion Distribution by Age Group')
plt.xlabel('Age Group')
plt.ylabel('Count')
plt.xticks(rotation=0)
plt.legend(title='Conversion', labels=['No (0)', 'Yes (1)'])
plt.tight_layout()
plt.show()

new_customers=df[df['PreviousPurchases']==0]
new_customer_conversions= new_customers["Conversion"].sum()
total_new_customers=len(new_customers)
first_time_conversion_rate = (new_customer_conversions / total_new_customers) * 100

print(f"Total new customers: {total_new_customers}")
print(f"Total conversions from new customers: {new_customer_conversions}")
print(f"First-time conversion rate: {first_time_conversion_rate:.2f}%")

Total new customers: 838
Total conversions from new customers: 648
First-time conversion rate: 77.33%

labels = ["Converted", "Not Converted"]
values = [new_customer_conversions, total_new_customers - new_customer_conversions]

colors = ['#1f77b4', '#ff7f0e']  # Example colors from 'tab10'

plt.figure(figsize=(5, 5))
plt.pie(values, labels=labels, autopct='%1.1f%%', colors=colors, startangle=90)

plt.title("First-Time Customer Conversion Distribution")
plt.axis('equal')

plt.show()

income_bins=[20000,50000,100000,150001]
income_labels=['Low','Medium','High']
df_copy['IncomeGroup']=pd.cut(df_copy['Income'], bins=income_bins, labels=income_labels, right=False)

import matplotlib.pyplot as plt

# Group by IncomeGroup and Conversion
conversion_income = df_copy.groupby(['IncomeGroup', 'Conversion']).size().unstack()

# Plot with custom colors
ax = conversion_income.plot(kind='bar', figsize=(8, 6), color=['#e76f51', '#2a9d8f'], edgecolor='black')

# Add value labels to each bar
for p in ax.patches:
    height = p.get_height()
    if height > 0:
        ax.annotate(f'{int(height)}',
                    (p.get_x() + p.get_width() / 2., height),
                    ha='center', va='bottom',
                    fontsize=9, color='black',
                    xytext=(0, 3), textcoords='offset points')

# Titles and labels
plt.title('Conversion Distribution by Income Group')
plt.xlabel('Income Group')
plt.ylabel('Count')
plt.xticks(rotation=0)
plt.legend(title='Conversion', labels=['No (0)', 'Yes (1)'])
plt.tight_layout()
plt.show()

# Check for duplicate rows
duplicates = df.duplicated()

# Count total duplicates
num_duplicates = duplicates.sum()
print(f"Number of duplicate rows: {num_duplicates}")

Number of duplicate rows: 0

# Check for missing values in the dataset
df.isnull().sum().sum()

0

continuous_features

['Age',
 'Income',
 'AdSpend',
 'ClickThroughRate',
 'ConversionRate',
 'WebsiteVisits',
 'PagesPerVisit',
 'TimeOnSite',
 'SocialShares',
 'EmailOpens',
 'EmailClicks',
 'PreviousPurchases',
 'LoyaltyPoints']

Q1 = df[continuous_features].quantile(0.25)
Q3 = df[continuous_features].quantile(0.75)
IQR = Q3 - Q1
outliers_count_specified = ((df[continuous_features] < (Q1 - 1.5 * IQR)) | (df[continuous_features] > (Q3 + 1.5 * IQR))).sum()

outliers_count_specified

Age                  0
Income               0
AdSpend              0
ClickThroughRate     0
ConversionRate       0
WebsiteVisits        0
PagesPerVisit        0
TimeOnSite           0
SocialShares         0
EmailOpens           0
EmailClicks          0
PreviousPurchases    0
LoyaltyPoints        0
dtype: int64

# Set up the plotting area
plt.figure(figsize=(15, 8))
sns.set(style="whitegrid")

# Create boxplots for each continuous feature
df[continuous_features].plot(kind='box', subplots=True, layout=(2, int(len(continuous_features)/2) + 1),
                             figsize=(18, 10), patch_artist=True, boxprops=dict(facecolor='#d0f0fd'))

plt.suptitle('Boxplots of Continuous Features', fontsize=16)
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.show()

<Figure size 1500x800 with 0 Axes>

categorical_features

['Gender', 'CampaignChannel', 'CampaignType']

# Perform one-hot encoding and convert boolean to integer (0/1)
df = pd.get_dummies(df, columns=['Gender','CampaignChannel', 'CampaignType'], drop_first=False)
df[df.select_dtypes(include=['bool']).columns] = df.select_dtypes(include=['bool']).astype(int)

df.head(4)

df.columns

Index(['Age', 'Income', 'AdSpend', 'ClickThroughRate', 'ConversionRate',
       'WebsiteVisits', 'PagesPerVisit', 'TimeOnSite', 'SocialShares',
       'EmailOpens', 'EmailClicks', 'PreviousPurchases', 'LoyaltyPoints',
       'Conversion', 'Gender_Female', 'Gender_Male', 'CampaignChannel_Email',
       'CampaignChannel_PPC', 'CampaignChannel_Referral',
       'CampaignChannel_SEO', 'CampaignChannel_Social Media',
       'CampaignType_Awareness', 'CampaignType_Consideration',
       'CampaignType_Conversion', 'CampaignType_Retention'],
      dtype='object')

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 8000 entries, 0 to 7999
Data columns (total 25 columns):
 #   Column                        Non-Null Count  Dtype  
---  ------                        --------------  -----  
 0   Age                           8000 non-null   int64  
 1   Income                        8000 non-null   int64  
 2   AdSpend                       8000 non-null   float64
 3   ClickThroughRate              8000 non-null   float64
 4   ConversionRate                8000 non-null   float64
 5   WebsiteVisits                 8000 non-null   int64  
 6   PagesPerVisit                 8000 non-null   float64
 7   TimeOnSite                    8000 non-null   float64
 8   SocialShares                  8000 non-null   int64  
 9   EmailOpens                    8000 non-null   int64  
 10  EmailClicks                   8000 non-null   int64  
 11  PreviousPurchases             8000 non-null   int64  
 12  LoyaltyPoints                 8000 non-null   int64  
 13  Conversion                    8000 non-null   int64  
 14  Gender_Female                 8000 non-null   int32  
 15  Gender_Male                   8000 non-null   int32  
 16  CampaignChannel_Email         8000 non-null   int32  
 17  CampaignChannel_PPC           8000 non-null   int32  
 18  CampaignChannel_Referral      8000 non-null   int32  
 19  CampaignChannel_SEO           8000 non-null   int32  
 20  CampaignChannel_Social Media  8000 non-null   int32  
 21  CampaignType_Awareness        8000 non-null   int32  
 22  CampaignType_Consideration    8000 non-null   int32  
 23  CampaignType_Conversion       8000 non-null   int32  
 24  CampaignType_Retention        8000 non-null   int32  
dtypes: float64(5), int32(11), int64(9)
memory usage: 1.2 MB

df['Conversion'].value_counts()

Conversion
1    7012
0     988
Name: count, dtype: int64

labels = ['Converted', 'Not Converted']
values = df['Conversion'].value_counts()
colors=['#1f77b4', '#ff7f0e']

plt.figure(figsize=(5, 5))
plt.pie(values, labels=labels, autopct='%1.1f%%', colors=colors, startangle=90)

plt.title("Customer Conversion Distribution")
plt.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.

# Show the plot
plt.show()

# Define the features (X) and the output labels (y)
X = df.drop('Conversion', axis=1)
y = df['Conversion']

y.value_counts()

Conversion
1    7012
0     988
Name: count, dtype: int64

from imblearn.over_sampling import SMOTE

smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(X, y)

# Check the new class distribution
new_class_distribution = y_resampled.value_counts()
print(new_class_distribution)

Conversion
1    7012
0    7012
Name: count, dtype: int64

X_train, X_test, y_train, y_test = train_test_split(X_resampled, y_resampled, test_size=0.2, random_state=42,stratify=y_resampled)

# Print the shapes of the resulting sets
print("Training set shape:", X_train.shape)
print("Testing set shape:", X_test.shape)
print("Training target shape:", y_train.shape)
print("Testing target shape:", y_test.shape)

Training set shape: (11219, 24)
Testing set shape: (2805, 24)
Training target shape: (11219,)
Testing target shape: (2805,)

numerical_cols = ['Age', 'Income', 'AdSpend', 'ClickThroughRate', 'ConversionRate',
                  'WebsiteVisits', 'PagesPerVisit', 'TimeOnSite', 'SocialShares',
                  'EmailOpens', 'EmailClicks', 'PreviousPurchases', 'LoyaltyPoints']

# Initialize scaler
scaler = StandardScaler()

# Fit on training data numerical columns
X_train[numerical_cols] = scaler.fit_transform(X_train[numerical_cols])

# Transform test data numerical columns
X_test[numerical_cols] = scaler.transform(X_test[numerical_cols])

X_train.head()

# Define parameter grid for Logistic Regression
param_grid = {
    'penalty': ['l1', 'l2'],
    'C': [0.01, 0.1, 1, 10, 100],
    'solver': ['liblinear']  # 'liblinear' supports both l1 and l2 penalties
}

# Initialize base model
lr = LogisticRegression(random_state=42)

# Create StratifiedKFold cross-validator
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# Set up GridSearchCV
grid_search = GridSearchCV(
    estimator=lr,
    param_grid=param_grid,
    cv=cv,
    scoring='f1',
    n_jobs=-1
)

# Perform grid search
grid_search.fit(X_train, y_train)

# Extract best parameters
best_params = grid_search.best_params_
print("Best Hyperparameters:", best_params)


# Initialize Logistic Regression with best parameters
final_lr_model = LogisticRegression(
    penalty=best_params['penalty'],
    C=best_params['C'],
    solver=best_params['solver'],
    random_state=42
)

# Train the final model
final_lr_model.fit(X_train, y_train)

Best Hyperparameters: {'C': 100, 'penalty': 'l1', 'solver': 'liblinear'}

LogisticRegression(C=100, penalty='l1', random_state=42, solver='liblinear')

LogisticRegression(C=100, penalty='l1', random_state=42, solver='liblinear')

# Make predictions
y_pred = final_lr_model.predict(X_test)

# Evaluation Metrics
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)

# Print evaluation results
print("\nModel Evaluation Metrics:")
print(f"Accuracy : {accuracy:.4f}")
print(f"Precision: {precision:.4f}")
print(f"Recall   : {recall:.4f}")
print(f"F1 Score : {f1:.4f}")

Model Evaluation Metrics:
Accuracy : 0.9358
Precision: 0.8947
Recall   : 0.9879
F1 Score : 0.9390

# Generate classification report
report = classification_report(y_test, y_pred)
print("Classification Report:")
print(report)

Classification Report:
              precision    recall  f1-score   support

           0       0.99      0.88      0.93      1403
           1       0.89      0.99      0.94      1402

    accuracy                           0.94      2805
   macro avg       0.94      0.94      0.94      2805
weighted avg       0.94      0.94      0.94      2805

# Confusion matrix as heatmap
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=["Not Converted", "Converted"],
            yticklabels=["Not Converted", "Converted"])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix - Logistic Regression')
plt.show()

# Define parameter grid for GridSearchCV
param_grid = {
    'criterion': ['gini', 'entropy'],
    'max_depth': [3, 5, 10, 15, None],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4]
}

# Initialize base Decision Tree
dt = DecisionTreeClassifier(random_state=42)

# StratifiedKFold for cross-validation
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# GridSearchCV setup
grid_search = GridSearchCV(estimator=dt,
                           param_grid=param_grid,
                           cv=cv,
                           scoring='f1',
                           n_jobs=-1)

# Fit to training data
grid_search.fit(X_train, y_train)


# Best hyperparameters
best_params = grid_search.best_params_
print("Best Hyperparameters:", best_params)

Best Hyperparameters: {'criterion': 'entropy', 'max_depth': None, 'min_samples_leaf': 1, 'min_samples_split': 2}

# Final model with best params
final_dt_model = DecisionTreeClassifier(
    criterion=best_params['criterion'],
    max_depth=best_params['max_depth'],
    min_samples_split=best_params['min_samples_split'],
    min_samples_leaf=best_params['min_samples_leaf'],
    random_state=42
)

# Fit final model
final_dt_model.fit(X_train, y_train)

# Predict on test set
y_pred = final_dt_model.predict(X_test)

# Evaluate
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)

# Show metrics
print("Model Evaluation Metrics:")
print(f"Accuracy : {accuracy:.4f}")
print(f"Precision: {precision:.4f}")
print(f"Recall   : {recall:.4f}")
print(f"F1 Score : {f1:.4f}")

Model Evaluation Metrics:
Accuracy : 0.8770
Precision: 0.8849
Recall   : 0.8666
F1 Score : 0.8757

from sklearn.metrics import classification_report

# Generate classification report
report = classification_report(y_test, y_pred)
print("Classification Report:")
print(report)

Classification Report:
              precision    recall  f1-score   support

           0       0.87      0.89      0.88      1403
           1       0.88      0.87      0.88      1402

    accuracy                           0.88      2805
   macro avg       0.88      0.88      0.88      2805
weighted avg       0.88      0.88      0.88      2805

from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

# Compute confusion matrix
cm = confusion_matrix(y_test, y_pred)

# Plot confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=["Not Converted", "Converted"], yticklabels=["Not Converted", "Converted"])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()

# Define parameter grid for Random Forest
param_grid = {
    'n_estimators': [10, 50, 200],
    'max_depth': [5, 10, 20, None],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
    'criterion': ['gini', 'entropy']
}

# Initialize base Random Forest
rf = RandomForestClassifier(random_state=42)

# StratifiedKFold for consistent class representation
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# GridSearchCV for hyperparameter tuning
grid_search = GridSearchCV(estimator=rf,
                           param_grid=param_grid,
                           cv=cv,
                           scoring='f1',
                           n_jobs=-1)

# Fit to training data
grid_search.fit(X_train, y_train)

# Best hyperparameters
best_params = grid_search.best_params_
print("Best Hyperparameters:", best_params)

Best Hyperparameters: {'criterion': 'entropy', 'max_depth': 20, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}

# Final model with best parameters
final_rf_model = RandomForestClassifier(
    n_estimators=best_params['n_estimators'],
    max_depth=best_params['max_depth'],
    min_samples_split=best_params['min_samples_split'],
    min_samples_leaf=best_params['min_samples_leaf'],
    criterion=best_params['criterion'],
    random_state=42
)

# Fit final model on full training data
final_rf_model.fit(X_train, y_train)

# Predict on test set
y_pred = final_rf_model.predict(X_test)

# Evaluate the model
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)

# Display results
print("Random Forest Model Evaluation Metrics:")
print(f"Accuracy : {accuracy:.4f}")
print(f"Precision: {precision:.4f}")
print(f"Recall   : {recall:.4f}")
print(f"F1 Score : {f1:.4f}")

Random Forest Model Evaluation Metrics:
Accuracy : 0.9487
Precision: 0.9122
Recall   : 0.9929
F1 Score : 0.9508

# Generate classification report
report = classification_report(y_test, y_pred)
print("Classification Report:")
print(report)

Classification Report:
              precision    recall  f1-score   support

           0       0.99      0.90      0.95      1403
           1       0.91      0.99      0.95      1402

    accuracy                           0.95      2805
   macro avg       0.95      0.95      0.95      2805
weighted avg       0.95      0.95      0.95      2805

# Compute confusion matrix
cm = confusion_matrix(y_test, y_pred)

# Plot confusion matrix
plt.figure(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=["Not Converted", "Converted"], yticklabels=["Not Converted", "Converted"])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()

# Define parameter grid for SVM
param_grid = {
    'C': [0.1, 1, 10],
    'kernel': ['linear', 'rbf', 'poly'],
    'gamma': ['scale', 'auto']  # used for non-linear kernels
}

# Initialize SVC
svm = SVC(random_state=42)

# Stratified K-Fold cross-validation
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# GridSearchCV
grid_search = GridSearchCV(estimator=svm,
                           param_grid=param_grid,
                           cv=cv,
                           scoring='f1',
                           n_jobs=-1)

# Fit grid search
grid_search.fit(X_train, y_train)


# Best hyperparameters
best_params = grid_search.best_params_
print("Best Hyperparameters:", best_params)

Best Hyperparameters: {'C': 10, 'gamma': 'auto', 'kernel': 'rbf'}

# Final SVM model with best params
final_svm_model = SVC(
    C=best_params['C'],
    kernel=best_params['kernel'],
    gamma=best_params['gamma'],
    random_state=42
)

# Fit final model
final_svm_model.fit(X_train, y_train)

# Predict on test set
y_pred = final_svm_model.predict(X_test)

# Evaluation metrics
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)

# Display metrics
print("Model Evaluation Metrics:")
print(f"Accuracy : {accuracy:.4f}")
print(f"Precision: {precision:.4f}")
print(f"Recall   : {recall:.4f}")
print(f"F1 Score : {f1:.4f}")

Model Evaluation Metrics:
Accuracy : 0.9398
Precision: 0.9075
Recall   : 0.9793
F1 Score : 0.9420

# Classification report
print("\nClassification Report:")
print(classification_report(y_test, y_pred))

Classification Report:
              precision    recall  f1-score   support

           0       0.98      0.90      0.94      1403
           1       0.91      0.98      0.94      1402

    accuracy                           0.94      2805
   macro avg       0.94      0.94      0.94      2805
weighted avg       0.94      0.94      0.94      2805

# Confusion matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=["Not Converted", "Converted"],
            yticklabels=["Not Converted", "Converted"])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix - SVM')
plt.show()

# Define parameter grid for GridSearchCV
param_grid = {
    'n_estimators': [100, 200],
    'max_depth': [3, 5, 7],
    'learning_rate': [0.01, 0.1, 0.2],
    'subsample': [0.8, 1.0],
    'colsample_bytree': [0.8, 1.0]
}

# Initialize base model
xgb = XGBClassifier(use_label_encoder=False, eval_metric='logloss', random_state=42)

# Cross-validation strategy
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# GridSearchCV
grid_search = GridSearchCV(estimator=xgb,
                           param_grid=param_grid,
                           cv=cv,
                           scoring='f1',
                           n_jobs=-1,
                           verbose=1)

# Fit to training data
grid_search.fit(X_train, y_train)

# Best hyperparameters
best_params = grid_search.best_params_
print("Best Hyperparameters:", best_params)

Fitting 5 folds for each of 72 candidates, totalling 360 fits

C:\Users\DELL\anaconda3\Lib\site-packages\xgboost\training.py:183: UserWarning: [11:33:57] WARNING: C:\actions-runner\_work\xgboost\xgboost\src\learner.cc:738: 
Parameters: { "use_label_encoder" } are not used.

  bst.update(dtrain, iteration=i, fobj=obj)

Best Hyperparameters: {'colsample_bytree': 1.0, 'learning_rate': 0.1, 'max_depth': 7, 'n_estimators': 200, 'subsample': 0.8}

# Final model with best parameters
final_xgb_model = XGBClassifier(
    use_label_encoder=False,
    eval_metric='logloss',
    random_state=42,
    **best_params
)

# Fit model
final_xgb_model.fit(X_train, y_train)

# Predict
y_pred = final_xgb_model.predict(X_test)

# Evaluate
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)

C:\Users\DELL\anaconda3\Lib\site-packages\xgboost\training.py:183: UserWarning: [11:33:57] WARNING: C:\actions-runner\_work\xgboost\xgboost\src\learner.cc:738: 
Parameters: { "use_label_encoder" } are not used.

  bst.update(dtrain, iteration=i, fobj=obj)

print("\nModel Evaluation Metrics:")
print(f"Accuracy : {accuracy:.4f}")
print(f"Precision: {precision:.4f}")
print(f"Recall   : {recall:.4f}")
print(f"F1 Score : {f1:.4f}")

Model Evaluation Metrics:
Accuracy : 0.9554
Precision: 0.9254
Recall   : 0.9907
F1 Score : 0.9569

# Classification report
print("\nClassification Report:")
print(classification_report(y_test, y_pred))

Classification Report:
              precision    recall  f1-score   support

           0       0.99      0.92      0.95      1403
           1       0.93      0.99      0.96      1402

    accuracy                           0.96      2805
   macro avg       0.96      0.96      0.96      2805
weighted avg       0.96      0.96      0.96      2805

# Confusion matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=["Not Converted", "Converted"],
            yticklabels=["Not Converted", "Converted"])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix - XGBoost')
plt.show()

from sklearn.metrics import roc_curve, auc

# Get predicted probabilities
dt_probs = final_dt_model.predict_proba(X_test)[:, 1]
rf_probs = final_rf_model.predict_proba(X_test)[:, 1]
lr_probs = final_lr_model.predict_proba(X_test)[:, 1]
svm_probs = final_svm_model.decision_function(X_test)
xgb_probs = final_xgb_model.predict_proba(X_test)[:, 1]

# Compute ROC curve and AUC for each model
fpr_dt, tpr_dt, _ = roc_curve(y_test, dt_probs)
fpr_rf, tpr_rf, _ = roc_curve(y_test, rf_probs)
fpr_lr, tpr_lr, _ = roc_curve(y_test, lr_probs)
fpr_svm, tpr_svm, _ = roc_curve(y_test, svm_probs)
fpr_xgb, tpr_xgb, _ = roc_curve(y_test, xgb_probs)

auc_dt = auc(fpr_dt, tpr_dt)
auc_rf = auc(fpr_rf, tpr_rf)
auc_lr = auc(fpr_lr, tpr_lr)
auc_svm = auc(fpr_svm, tpr_svm)
auc_xgb = auc(fpr_xgb, tpr_xgb)

# Plotting
plt.figure(figsize=(10, 7))
plt.plot(fpr_dt, tpr_dt, label=f'Decision Tree (AUC = {auc_dt:.2f})')
plt.plot(fpr_rf, tpr_rf, label=f'Random Forest (AUC = {auc_rf:.2f})')
plt.plot(fpr_lr, tpr_lr, label=f'Logistic Regression (AUC = {auc_lr:.2f})')
plt.plot(fpr_svm, tpr_svm, label=f'SVM (AUC = {auc_svm:.2f})')
plt.plot(fpr_xgb, tpr_xgb, label=f'XGBoost (AUC = {auc_xgb:.2f})')

# Diagonal line
plt.plot([0, 1], [0, 1], 'k--')

# Plot aesthetics
plt.title('ROC Curve Comparison')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.legend(loc='lower right')
plt.grid(True)
plt.show()

	CustomerID	Age	Gender	Income	CampaignChannel	CampaignType	AdSpend	ClickThroughRate	ConversionRate	WebsiteVisits	PagesPerVisit	TimeOnSite	SocialShares	EmailOpens	EmailClicks	PreviousPurchases	LoyaltyPoints	AdvertisingPlatform	AdvertisingTool	Conversion
0	8000	56	Female	136912	Social Media	Awareness	6497.870068	0.043919	0.088031	0	2.399017	7.396803	19	6	9	4	688	IsConfid	ToolConfid	1
1	8001	69	Male	41760	Email	Retention	3898.668606	0.155725	0.182725	42	2.917138	5.352549	5	2	7	2	3459	IsConfid	ToolConfid	1
2	8002	46	Female	88456	PPC	Awareness	1546.429596	0.277490	0.076423	2	8.223619	13.794901	0	11	2	8	2337	IsConfid	ToolConfid	1
3	8003	32	Female	44085	PPC	Conversion	539.525936	0.137611	0.088004	47	4.540939	14.688363	89	2	2	0	2463	IsConfid	ToolConfid	1
4	8004	60	Female	83964	PPC	Conversion	1678.043573	0.252851	0.109940	0	2.046847	13.993370	6	6	6	8	4345	IsConfid	ToolConfid	1
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
7995	15995	21	Male	24849	Email	Awareness	8518.308575	0.243792	0.116773	23	9.693602	14.227794	70	13	6	7	286	IsConfid	ToolConfid	0
7996	15996	43	Female	44718	SEO	Retention	1424.613446	0.236740	0.190061	49	9.499010	3.501106	52	13	1	5	1502	IsConfid	ToolConfid	0
7997	15997	28	Female	125471	Referral	Consideration	4609.534635	0.056526	0.133826	35	2.853241	14.618323	38	16	0	3	738	IsConfid	ToolConfid	1
7998	15998	19	Female	107862	PPC	Consideration	9476.106354	0.023961	0.138386	49	1.002964	3.876623	86	1	5	7	2709	IsConfid	ToolConfid	1
7999	15999	31	Female	93002	Email	Awareness	7743.627070	0.185670	0.057228	15	6.964739	12.763660	2	18	9	9	341	IsConfid	ToolConfid	0

	count	mean	std	min	25%	50%	75%	max
CustomerID	8000.0	11999.500000	2309.545410	8000.000000	9999.750000	11999.500000	13999.250000	15999.000000
Age	8000.0	43.625500	14.902785	18.000000	31.000000	43.000000	56.000000	69.000000
Income	8000.0	84664.196750	37580.387945	20014.000000	51744.500000	84926.500000	116815.750000	149986.000000
AdSpend	8000.0	5000.944830	2838.038153	100.054813	2523.221165	5013.440044	7407.989369	9997.914781
ClickThroughRate	8000.0	0.154829	0.084007	0.010005	0.082635	0.154505	0.228207	0.299968
ConversionRate	8000.0	0.104389	0.054878	0.010018	0.056410	0.104046	0.152077	0.199995
WebsiteVisits	8000.0	24.751625	14.312269	0.000000	13.000000	25.000000	37.000000	49.000000
PagesPerVisit	8000.0	5.549299	2.607358	1.000428	3.302479	5.534257	7.835756	9.999055
TimeOnSite	8000.0	7.727718	4.228218	0.501669	4.068340	7.682956	11.481468	14.995311
SocialShares	8000.0	49.799750	28.901165	0.000000	25.000000	50.000000	75.000000	99.000000
EmailOpens	8000.0	9.476875	5.711111	0.000000	5.000000	9.000000	14.000000	19.000000
EmailClicks	8000.0	4.467375	2.856564	0.000000	2.000000	4.000000	7.000000	9.000000
PreviousPurchases	8000.0	4.485500	2.888093	0.000000	2.000000	4.000000	7.000000	9.000000
LoyaltyPoints	8000.0	2490.268500	1429.527162	0.000000	1254.750000	2497.000000	3702.250000	4999.000000
Conversion	8000.0	0.876500	0.329031	0.000000	1.000000	1.000000	1.000000	1.000000

Variable	Description
CustomerID	Unique identifier for each customer
Age	Age of the customer
Gender	Gender of the customer (Male/Female)
Income	Annual income of the customer
CampaignChannel	Marketing channel used for the campaign (e.g., Social Media, Email, PPC, SEO, Referral)
CampaignType	Stage of marketing campaign (Awareness, Retention, Conversion, Consideration)
AdSpend	Advertising spend on the customer (in monetary units)
ClickThroughRate	Ratio of users who clicked on a marketing advertisement
ConversionRate	Ratio of users who completed the desired action (purchase, signup, etc.)
WebsiteVisits	Number of times the customer visited the website
PagesPerVisit	Average number of pages viewed per website visit
TimeOnSite	Average time (in minutes) spent on the website per visit
SocialShares	Number of times the customer shared content on social media
EmailOpens	Number of marketing emails opened by the customer
EmailClicks	Number of times the customer clicked inside marketing emails
PreviousPurchases	Number of previous purchases made by the customer
LoyaltyPoints	Loyalty points accumulated by the customer
AdvertisingPlatform	Platform used for advertising (e.g., IsConfid)
AdvertisingTool	Tool used within the advertising platform (e.g., ToolConfid)
Conversion	Whether the customer converted (0 = No, 1 = Yes)

	count	mean	std	min	25%	50%	75%	max
CustomerID	8000.0	11999.500000	2309.545410	8000.000000	9999.750000	11999.500000	13999.250000	15999.000000
Age	8000.0	43.625500	14.902785	18.000000	31.000000	43.000000	56.000000	69.000000
Income	8000.0	84664.196750	37580.387945	20014.000000	51744.500000	84926.500000	116815.750000	149986.000000
AdSpend	8000.0	5000.944830	2838.038153	100.054813	2523.221165	5013.440044	7407.989369	9997.914781
ClickThroughRate	8000.0	0.154829	0.084007	0.010005	0.082635	0.154505	0.228207	0.299968
ConversionRate	8000.0	0.104389	0.054878	0.010018	0.056410	0.104046	0.152077	0.199995
WebsiteVisits	8000.0	24.751625	14.312269	0.000000	13.000000	25.000000	37.000000	49.000000
PagesPerVisit	8000.0	5.549299	2.607358	1.000428	3.302479	5.534257	7.835756	9.999055
TimeOnSite	8000.0	7.727718	4.228218	0.501669	4.068340	7.682956	11.481468	14.995311
SocialShares	8000.0	49.799750	28.901165	0.000000	25.000000	50.000000	75.000000	99.000000
EmailOpens	8000.0	9.476875	5.711111	0.000000	5.000000	9.000000	14.000000	19.000000
EmailClicks	8000.0	4.467375	2.856564	0.000000	2.000000	4.000000	7.000000	9.000000
PreviousPurchases	8000.0	4.485500	2.888093	0.000000	2.000000	4.000000	7.000000	9.000000
LoyaltyPoints	8000.0	2490.268500	1429.527162	0.000000	1254.750000	2497.000000	3702.250000	4999.000000
Conversion	8000.0	0.876500	0.329031	0.000000	1.000000	1.000000	1.000000	1.000000

	Age	Income	AdSpend	ClickThroughRate	ConversionRate	WebsiteVisits	PagesPerVisit	TimeOnSite	SocialShares	EmailOpens	EmailClicks	PreviousPurchases	LoyaltyPoints
0	56	136912	6497.870068	0.043919	0.088031	0	2.399017	7.396803	19	6	9	4	688
1	69	41760	3898.668606	0.155725	0.182725	42	2.917138	5.352549	5	2	7	2	3459
2	46	88456	1546.429596	0.277490	0.076423	2	8.223619	13.794901	0	11	2	8	2337
3	32	44085	539.525936	0.137611	0.088004	47	4.540939	14.688363	89	2	2	0	2463
4	60	83964	1678.043573	0.252851	0.109940	0	2.046847	13.993370	6	6	6	8	4345

	Age	Income	AdSpend	ClickThroughRate	ConversionRate	WebsiteVisits	PagesPerVisit	TimeOnSite	SocialShares	EmailOpens	...	Gender_Male	CampaignChannel_Email	CampaignChannel_PPC	CampaignType_Retention
2224	0.685275	-0.790353	-1.232939	0.818984	-1.355811	0.339270	-0.778379	-1.403490	1.501095	0.833101	...	0	1	0	1
5308	0.254001	-0.321464	1.470997	0.224511	-0.969399	1.430018	1.863138	-0.867097	-1.865357	-0.632998	...	0	0	1	1
11568	-0.249151	1.498519	0.729909	1.497862	0.386207	-1.187776	-0.613549	1.464324	-0.107321	0.100052	...	0	0	0	0
9813	-0.033514	-1.348645	1.364625	-1.351432	-1.043838	0.993719	-1.018782	-0.731065	-0.967636	-1.182785	...	0	1	0	0
1825	0.541517	1.201634	-1.423096	-0.812299	1.143298	-0.097029	0.917437	-1.566180	1.276665	-1.549309	...	1	0	1	1

Model	Accuracy	Precision	Recall	AUC
XGBoost	95%	92%	99%	0.98
Random Forest	95%	91%	99%	0.98
Support Vector Machine (SVM)	93%	90%	97%	0.97
Logistic Regression	93%	89%	98%	0.97
Decision Tree	87%	88%	86%	0.87

Problem:

Objective:

Workflow:

Step 1 | Import Libraries¶

Step 2 | Read Dataset¶

Dataset Description:

Step 3 | Dataset Overview¶

Step 3.1 | Dataset Basic Information¶

Inferences:

Step 3.2 | Summary Statistics for Numerical Variables¶

Numerical Features:

Step 3.3 | Summary Statistics for Categorical Variables¶

Categorical Features:

Step 4 | EDA¶

Before EDA Droping Irrelevant Columns:

Feature Removal Justification:

Step 4.1 | Univariate Analysis¶

Step 4.1.1 | Numerical Variables Univariate Analysis

Inferences:

Step 4.1.2 | Categorical Variables Univariate Analysis

Inferences:

Step 4.2 | Bivariate Analysis¶

Step 4.2.1 | Numerical Features vs Conversion

Inferences:

Step 4.2.2 | Categorical Features vs Conversion

Inferences:

Step 4.3 | Correlation Heatmap

Inferences:

Step 4.4 |Income Distribution by Gender

Inference from Box Plot: Income Distribution by Gender

Step 4.5 |Conversion Rate by Campaign Type

Inference from Pie Chart: Conversion Rate by Campaign Type

Step 4.6 | Website Engagement Metrics

Inference from Bar Charts: User Engagement Metrics by Conversion Status

Step 4.7 | Conversion by Gender

Inference from Bar Chart: Conversion Distribution by Gender

Step 4.8 | Conversion by Campaign Channel

Inference from Bar Chart: Conversions by Campaign Channel

Step 4.9 | Conversions per Campaign Channel

Inference from Bar Chart: Conversions per Campaign Channel

Step 4.10 | Gender Distribution by Campaign Channel

Inference from Bar Chart: Gender Distribution by Campaign Channel

Step 4.11 | Campaign Channel Distribution by Gender

Inference from Bar Chart: Campaign Channel Distribution by Gender

Step 4.12 | Age Group Distribution & Conversion Distribution by Age Group

Age Group Distribution

Inference from Bar Chart: Age Group Distribution

Conversion Distribution by Age Group

Inference from Bar Chart: Conversion Distribution by Age Group

Step 4.13 | First-Time Customer Conversion Distribution

Inference from Pie Chart: First-Time Customer Conversion

Step 4.14 | Conversion Distribution by Income Group

Inference from Bar Chart: Conversion by Income Group

Step 5 | Data Preprocessing ¶

Step 5.1 | Irrelevant Features Removal¶

Step 5.2 | Checking Duplicates¶

Step 5.2 | Missing Value Treatment¶

Step 5.3 | Outlier Treatment¶

Step 5.4 | Categorical Features Encoding¶

One-hot Encoding Decision for Categorical Features:

Summary:

For Gender, CampaignChannel and CampaignType ¶

Step 5.5 | Customer Conversion Distribution¶

Step 5.6 | Splitting data into X and y set ¶

Step 5.7 | Over Sampling using SMOTE ¶

Step 5.8 | Spliting Data into Train and Test ¶

Step 5.9 | Scaling Numerical Columns ¶

Step 6 | Logistic Regression Model Building¶

Step 7 | Decision Tree Model Building¶

Step 8 | Random Forest Model Building¶

Step 9 | SVM Model Building¶

Step 10 | XGBoost Model Building¶

Results :¶

Step 11 | AUC-ROC Curve For all Models¶

Inference from ROC Curve: Model AUC Comparison

Step 12 |Final Conclusion¶

1. Key Insights from EDA:¶

2. Model Performance Summary:¶

3. Business Takeaways:¶

Step 1 | Import Libraries
¶

Step 2 | Read Dataset
¶

Step 3 | Dataset Overview
¶

Step 4 | EDA
¶

Step 5 | Data Preprocessing
¶

Step 6 | Logistic Regression Model Building
¶

Step 7 | Decision Tree Model Building
¶

Step 8 | Random Forest Model Building
¶

Step 9 | SVM Model Building
¶

Step 10 | XGBoost Model Building
¶

Step 11 | AUC-ROC Curve For all Models
¶

Step 12 |Final Conclusion
¶